/* eslint-disable */
// 字符串复制n次
String.prototype.times = function (n) {
  return Array.prototype.join.call({length: n + 1}, this)
}
var entering = new Object()

/*
* 下面是最宽松条件下的识别模式
*/

entering.pattorns_loose = {
  scrap_head: /^\s*/g, // 去掉头部的任意个换行，空白，制表符
  scrap_tail: /\s*$/g, // 去掉尾部的任意个换行，空白，制表符
  scrap_space: /\s{3,}/g, // 去掉中间连续3个或以上空白符
  problem_split: /[^\s\S]/g, // 分割题目之间的标记
  sub_problem_split: /[\n\t][\s\t]*[⑴⑵⑶⑷⑸⑹⑺⑻⑼⑽]|[\n\t][\s\t]*[0-9]+[．、.]|[\n\t][\s\t]*[\(（]?[0-9]+[\)）]/g,
  // 分割小题之间的标记
  scrap_order_number: /^[0-9]+[．、.]|[⑴⑵⑶⑷⑸⑹⑺⑻⑼][．、.]?|^[\(（]?[0-9]+[\)）]|[【\[]?(?:(?:例)|(?:练习)|(?:巩固)|(?:变式)|(?:作业))题?[0-9]+[．、.]{0,2}[】\]]?/,
  // 题目的序号（需要去掉）
  analyze: /[\n\s\t\[【]+[解分]+[析答]?[\]】:：\s\n\t]+([\s\S]*)/,
  // 解析标识，捕获解析标识后面所有内容
  answer: /[\n\s\t\[【]+答案?[\]】:： \n\t]+([\s\S]*)/,
  // 答案标识，捕获答案标识后面所有内容
  option_D: /[\(（]?[ \t]?D[ \t]?[\)）．、.\n\t]+[ \t]*([\s\S]*)/,
  // D选项，捕获D选项标识后面所有内容
  option_C: /[\(（]?[ \t]?C[ \t]?[\)）．、.\n\t]+[ \t]*([\s\S]*)/,
  // C选项，同上
  option_B: /[\(（]?[ \t]?B[ \t]?[\)）．、.\n\t]+[ \t]*([\s\S]*)/,
  // B选项，同上
  option_A: /\s+[\(（]?[ \t]?A[ \t]?[\)）．、.\n\t]+[ \t]*([\s\S]*)/,
  // A选项，同上
  stem: /([\s\S]*)/,
  // 题干，捕获全部内容。
  blank: /\\\[\\text{ (?:\\\_){3,} }\\\]|\\\[\\text{ \_{3,} }\\\]| ?\_{3,} ?|[\(（][  \t]*[\)）]|(?:\\\[)?\((?:\\qquad)+\)(?:\\\])?|(?:\\\[)?\\left\((?:\\qquad)+\\right\)(?:\\\])?/g,
  // 填空题的横线或者选择题的选择括号。
  math_form: /\\\([^卐]+?\\\)|\\\[[^卐]+?\\\]|\$\$[^卐]+?\$\$|\$[^卐]+?\$/g,
  // 数学公式
  image: /「[^卐]*?」/g,
  // 图片
  article: /#[^卐]*?#/g,
  // 文章
  math_normal: /[_\+－\-\\\^\(\)（）\{\}\[\]<>\|& =\'.,≦≧≡×÷≤≥≈≠±:：∵∴∑∏∅∽∈∩∥△∆∞≌∉∪∠%％Δ|]*[0-9a-zA-Zαβγδεζηθικλμνξοπρστυφχψω]+[\n0-9a-zA-Zαβγδεζηθικλμνξοπρστυφχψω_\+－\-\\\^\(\)（）\{\}\[\]<>\|& =\'.,≦≧≡×÷≤≥≈≠±:：∵∴∑∏∅∽∈∩∥△∆∞≌∉∪∠%％Δαβγδεζηθικλμνξοπρστυφχψω|]*/g,
  // 非严格数学公式
  normal: /[^卐\n]+/g,
  // 普通文本
  new_line: /\n/g
  // 换行符
}

/*
* 1.先copy一个pattorns = copy(entering.pattorns_loose)，根据用户选择模式来修改属性。
* （1）识别所有公式，不用修改，
* （2）只识别严格公式，那就pattorns.math_normal = /[^\s\S]/
* （3）不识别公式，pattorns.math_normal = /[^\s\S]/，pattorns.math_form = /[^\s\S]/
*/

/*
* 下面是严格的识别模式
*
*/

entering.pattorns_stick = {
  scrap_head: /[^\s\S]/,
  scrap_tail: /[^\s\S]/,
  scrap_space: /[^\s\S]/g,
  problem_split: /[^\s\S]/g,
  sub_problem_split: /\n\([0-9]+\)/g,
  scrap_order_number: /[^\s\S]/,
  analyze: /\n解析：([\s\S]*)/,
  answer: /\n答案：([\s\S]*)/,
  option_D: /\nD．([\s\S]*)/,
  option_C: /\nC．([\s\S]*)/,
  option_B: /\nB．([\s\S]*)/,
  option_A: /\nA．([\s\S]*)/,
  stem: /([\s\S]*)/,
  blank: /\\\[\\text{ (?:\\\_){3,} }\\\]|\\\[\\text{ \_{3,} }\\\]| ?\_{3,} ?|[\(（][ \t]*[\)）]|(?:\\\[)?\((?:\\qquad)+\)(?:\\\])?|(?:\\\[)?\\left\((?:\\qquad)+\\right\)(?:\\\])?/g,
  math_form: /\\\([^卐]+?\\\)|\\\[[^卐]+?\\\]|\$\$[^卐]+?\$\$|\$[^卐]+?\$/g,
  image: /「[^卐]*?」/g,
  article: /#[^卐]*?#/g,
  math_normal: /[^\s\S]/g,
  normal: /[^卐\n]+/g,
  new_line: /\n/g
}

/*
* 文本数学公式中的一些字符应当转为tex代码
*/
entering.math_symbols = '≦≧≡×÷≤≥≈≠±:：∵∴∑∏∅∽∈∩∥△∆∞≌∉∪∠%％Δ'
entering.symbols_to_tex = {
  '<': '&lt',
  '≦': '\\leq',
  '≧': '\\geq',
  '≡': '\\equiv',
  '×': '\\times',
  '÷': '\\div',
  '≤': '\\leq',
  '≥': '\\geq',
  '≈': '\\approx',
  '≠': '\\ne',
  '±': '\\pm',
  '：': ':',
  '∵': '\\because',
  '∴': '\\therefore',
  '∑': '\\Sigma',
  '∏': '\\Pi',
  '∅': '\\emptyset',
  '∽': '\\sim',
  '∈': '\in',
  '∩': '\\cap',
  '∥': '\\parallel',
  '∆': '\\Delta',
  '△': '\\bigtriangleup',
  '∞': '\\infty',
  '%': '\\%',
  '％': '\\%',
  'Δ': '\\Delta'
}

var fs = function mf (element) {
  var s = ''
  if (element.nodeType == 3) {
    return element.nodeValue
  } else if (element.tagName == 'BR') {
    return '\n'
  } else if (element.tagName == 'IMG') {
    console.log(element.src)
    return '「' + element.src + '」'
  } else{
    for (var i = 0; i < element.childNodes.length; i++) {
      s += mf(element.childNodes[i])
    }
    if (element.tagName == 'DIV') {
      s = '卐' + s + '卐'
    }
  }
  return s
}

entering.get_string_from_element = function (element) {
/*
* 从element中获取字符串
*/

  var enter_string = fs(element)
  console.log('enter_string', enter_string)
  enter_string = enter_string.replace(/\n卐*/g, '\n').replace(/卐+/g, '\n')
  console.log('enter_string', enter_string)
  return enter_string.replace(/^\n+/, '')
}

entering.transform_problem_list = function (enter_string, pattorns) {
/*
1.接受一个输入的字符串，返回一个problem数组对象;
2.pattorns是很多个识别对象的正则表达式
 */

  entering.pattorns = pattorns
  enter_string = enter_string.replace(entering.pattorns.scrap_head, '')
  enter_string = enter_string.replace(entering.pattorns.scrap_tail, '')

  var joke_pattorn_1 = /人生就像一场梦！/g

  if (enter_string.match(joke_pattorn_1)) {
    enter_string = '#敬爱的前总统先生，您已经昏睡了十年了，您陷入了一个幻想的世界中不能自拔。我们通过现代计算机连接您的大脑，给您发送了这条消息。但是您的意识很难直接进入，我们不知道您能不能看到这条消息，也不知道您会在什么地方看到这个消息。无论如何，如果您有幸看到了这条消息，请赶快醒来！您的家人等您十年了！#'
  }

  var joke_pattorn_2 = /(.{0,3})程良伟/
  var x = enter_string.match(joke_pattorn_2)
  if (x) {
    if (x[1] == '大魔王') {
      enter_string = enter_string.replace(joke_pattorn_2, '程良伟')
    } else {
      enter_string = '敬爱的老师：#您好，我是软件代码作者，由于您录入的内容违反了《互联网技术行为准则规范》中的第十二章第三六条：“为了表示对开发者的尊重，不允许在软件中直接输入软件开发者的姓名。”，系统已经将您录入的内容全部和谐，如果需要确实需要输入原内容，请在作者姓名前加上“大魔王”。#'
    }
  }
  var problem_list = enter_string.split(entering.pattorns.problem_split)

  // 将字符串分割为题目序列，题目名称为problem
  for (var i = 0; i < problem_list.length; i++) {
    problem_list[i] = problem_list[i].replace(entering.pattorns.scrap_space, '')

    problem_list[i] = problem_list[i].replace(entering.pattorns.scrap_order_number, '')
    // 去掉题目序号
    problem_list[i] = problem_list[i].split(entering.pattorns.sub_problem_split)
    // 对每道题分割小题序列，小题名称为sub_problem
    for (var j = 0; j < problem_list[i].length; j++) {
      problem_list[i][j] = entering.transform_sub_problem(problem_list[i][j])
    // 对每道小题，用entering.transform_sub_problem将字符串化为小题对象。
    }
    problem_list[i].type = problem_list[i][0].type
    // 第一道小题的题目类型即为题目的暂定类型
    if (problem_list[i].length > 1) {
      problem_list[i].type = '综合题'
    }// 若小题数目超过1，则视为“综合题”。
  }
  console.log(problem_list)
  return problem_list
}

entering.transform_sub_problem = function (sub_problem_string) {
  sub_problem_string = sub_problem_string.replace(entering.pattorns.scrap_order_number, '')
  // 小题的序号去掉
  var sub_problem = new Object()

  function truncation_match (pattorn_name) {
  /* 依次匹配出解析，答案，D选项，C选项，B选项，A选项，然后删掉标识后面的部分。返回被删掉的部分。
   * 注意：只能是一次匹配正则表达式（不能是全局匹配）。返回捕获对象，若未匹配，返回undefined
   *
   */
    var pattorn = entering.pattorns[pattorn_name]
    var y = sub_problem_string.match(pattorn)
    sub_problem_string = sub_problem_string.replace(pattorn, '')// 被匹配的内容替换成空字符。
    if (y) {
      return y[1]
    }
    return undefined
  }
  // 下面是需要匹配的7个部分序列。
  var part_name_list = ['analyze', 'answer', 'option_D', 'option_C', 'option_B', 'option_A', 'stem']
  for (var i = 0; i < part_name_list.length; i++) {
    sub_problem[part_name_list[i]] = truncation_match(part_name_list[i])// 调用truncation_match函数。
    // 下面是对每个部分进行处理，详情见函数entering.transform_part
    sub_problem[part_name_list[i]] = entering.transform_part(sub_problem[part_name_list[i]], part_name_list[i])
  }
  sub_problem.type = '解答题'
  // 预设小题类型为“解答题”。
  for (var i = 0; i < 'ABCD'.length; i++) {
    if (sub_problem['option_' + 'ABCD'[i]]) {
      sub_problem.type = '选择题'
    }
  }// 有选项部分，则为“选择题”
  if (sub_problem.type == '解答题' && sub_problem.stem.blank) {
    sub_problem.type = '填空题'
  }// 为被修改为“选择题”，但是题干中有填空横线或者括号，则视为“填空题”。

  /*
 * 如果小题类型为“选择题”，则答案有限制。不符合的强制转化。
 */
  if (sub_problem.type == '选择题' && sub_problem.answer) {
    var new_part = {source: '', index: 0, type: 'normal'}
    var options = {A: false, B: false, C: false, D: false}
    for (var i = 0; i < sub_problem.answer.length; i++) {
      var x = sub_problem.answer[i].source.match(/[ABCD]/g)
      if (x) {
        for (var j = 0; j < x.length; j++) {
          options[x[j]] = true
        }
      }
      if (options.A && options.B && options.C && options.D) {
        break
      }
    }
    for (var i = 0; i < 'ABCD'.length; i++) {
      if (options['ABCD'[i]]) {
        new_part.source = new_part.source + 'ABCD'[i] + '，'
      }
    }
    new_part.source = new_part.source.slice(0, -1)
    sub_problem.answer = [new_part]
  }

  return sub_problem
}

entering.transform_part = function (part_str, part_name) {
/*
 * 该函数对每个部分（解析，答案，选项，题干）进行处理，返回一个数组，包含很多片段（sub_part)。
 */
  if (part_str == undefined) {
    return undefined
  }
  // 传入的字符串未定义，则返回未定义。

  var part = []
  // 存储所有的sub_part

  function replace_symbol (s) {
    return s.replace(/[\s\S]/g, '卐')
  }
  function replace_match (pattorn_name) {
  /*
   * pattron是全局正则表达式，匹配后的字符串替换为特殊字符'卐'
   * 匹配出的内容，以sub_part对象添加到part数组中。
   * sub_part的结构为{index:所处位置的索引,source:内容字符串,type:匹配的类型名称}
   */
    var b = false
    while (true) {
      var x = entering.pattorns[pattorn_name].exec(part_str)
      if (!x) {
        break
      }
      b = true
      var sub_part = new Object()
      sub_part.index = x.index
      // sub_part的起始位置
      sub_part.source = part_str.slice(x.index, entering.pattorns[pattorn_name].lastIndex)
      // sub_part的字符串
      sub_part.type = pattorn_name
      // sub_part的类型
      part.push(sub_part)
    // 将匹配出的sub_part添加到part数组中。
    }
    entering.pattorns[pattorn_name].lastIndex = 0
    part_str = part_str.replace(entering.pattorns[pattorn_name], replace_symbol)
    // 再来一次全局匹配替换为'卐'
    entering.pattorns[pattorn_name].lastIndex = 0
    // 重置lastIndex
    return b
  }

  if (part_name == 'stem') {
    part.blank = replace_match('blank')
  }
  // 题干需要匹配blank

  replace_match('math_form')// 匹配数学公式
  replace_match('image')// 匹配图片的地址索引
  replace_match('article')// 匹配文章
  replace_match('math_normal')// 数学模式下匹配文本公式
  replace_match('normal')// 匹配普通文本

  replace_match('new_line')// 匹配换行符

  function compare (p1, p2) { if (p1.index > p2.index) { return 1 } else { return -1 } }
  part = part.sort(compare)// 按sub_part.index来排序

  function change_math_normal (s) {
  /* 文本公式优化，在两边加上\[...\]
   * 全角小括号转化为半角
   * 删掉$符号。
   */
    s = '\\[' + s.replace('（', '(').replace('）', ')').replace('$', '') + '\\]'
    /*
   * 将一些特殊字符转化为tex语言。
   */
    for (var symbol_ in entering.symbols_to_tex) {
      s = s.replace(symbol_, entering.symbols_to_tex[symbol_] + ' ')
    }
    return s
  }
  function change_blank (s) {
  // blank优化
    var ss = s.match(/\_{3,}/)
    if (ss != null) {
      return '\\[\\text{ ' + '\\_'.times(Math.ceil(ss[0].length / 5) * 5) + ' }\\]'
    }
    ss = s.match(/(?:\\\_){3,}/)
    if (ss != null) {
      return '\\[\\text{ ' + '\\_'.times(Math.ceil(ss[0].length / 10) * 5) + ' }\\]'
    }
    ss = s.match(/ +/)
    if (ss != null) {
      return '\\[\\left(' + '\\qquad'.times(Math.ceil(ss[0].length / 6)) + '\\right)\\]'
    }
    ss = s.match(/(?:\\qquad)+/)
    if (ss != null) {
      return '\\[\\left(' + '\\qquad'.times(Math.ceil(ss[0].length / 6)) + '\\right)\\]'
    }
    return '\\[\\left(' + '\\qquad' + '\\right)\\]'
  }
  function change_math_form (s) {
  /*
   * 数学公式处理。
   */
    s = s.replace(/\\frac/g, '\\dfrac')
    s = s.replace(/\\begin\{matrix\}/g, '\\begin{array}{lll}')
    s = s.replace(/\\end\{matrix\}/g, '\\end{array}')
    s = s.replace(/</g, '&lt ')
    // 重要，放置<被html识别。
    return s
  }
  for (var i = 0; i < part.length; i++) {
    var sub_part = part[i]

    if (sub_part.type == 'math_normal') {
      sub_part.source = change_math_normal(sub_part.source)
      sub_part.type = 'math_form'
    }
    if (sub_part.type == 'blank') {
      sub_part.source = change_blank(sub_part.source)
    }
    if (sub_part.type == 'math_form') {
      sub_part.source = change_math_form(sub_part.source)
    }
  }
  part.type = part_name
  return part
}
/*
* *********************************************************************
* 华丽分割线
* ******************************************************************
*/

/*
* 渲染题目模块：
* 1.在某个div中渲染一个problem对象；
* 2.
*
*
*
*/

// render_answer_analyze

entering.render_problem = function (element, problem) {
/*
 * element是待渲染的div区域；
 * problem是待渲染的题目对象
 * 题目渲染的基本结构：
 * 	1.综合题页面
 * 		总题干：已知a+b=c，回答下列问题：（这部分类名为sub_problem_first_div)
 * 		（1）请问1+1=（  ）			|
 * 			A.1 B.2 C.3 D.4			|
 * 			答案：B					|
 * 			解析：太简单了，略		|这四行部分类名为sub_problem_div
 * 		（2）你有什么感想？
 * 			答案：略
 *
 *
 *
 * 2.单题页面
 * 		题干：请问2+3=____.
 * 		答案：5
 * 		解析：略
 *
 *
 *
 *
 */

  element.classList.add('render_problem_div')
  // 绑定render_problem_div类名
  element.innerHTML = ''
  // 清空element
  problem.last_element = element
  problem.hide_answer_analyze = function () {
    var list = this.last_element.getElementsByClassName('answer_analyze_div')
    for (var i = 0; i < list.length; i++) {
      list[i].classList.add('hide')
    }
  }

  problem.show_answer_analyze = function () {
    var list = this.last_element.getElementsByClassName('answer_analyze_div')
    for (var i = 0; i < list.length; i++) {
      list[i].classList.remove('hide')
    }
  }
  for (var i = 0; i < problem.length; i++) {
    var sub_problem = problem[i]
    var div = document.createElement('DIV')
    div.classList.add('sub_problem_div')
    element.appendChild(div)
    entering.render_sub_problem(div, problem[i], i)
  // 传入：待渲染区域，小题对象，题序号
  }
}

entering.render_sub_problem = function (element, sub_problem, i) {
/*
 * element为待渲染区域
 * sub_problem为小题对象（如果是综合题的第0个小题，其实就是总题干）
 * i为小题的序号
 */
  var ii = i
  if (sub_problem.stem) {
    var div = document.createElement('DIV')
    // 创建一个div
    element.appendChild(div)
    // 追加div
    if (i > 0) {
      div.innerHTML = '<span>(' + i + ') </span>'
    // 添加一个小题序号
    }
    div.classList.add('stem_div')
    // 题干部分类名为stem_div

    entering.render_part(div, sub_problem.stem)
  }
  if (sub_problem.type == '选择题') {
    var div = document.createElement('DIV')
    element.appendChild(div)
    div.classList.add('option_div')
    // 选项部分类名为option_div

    var option_ABCD_span_list = []
    var max_width = 0
    // 用来存储四个选项的最大长度
    for (var i = 0; i < 'ABCD'.length; i++) {
      var option_ABCD_span = entering.create_option_span(sub_problem, 'ABCD'[i])
      // 创建选项span,类名为option_ABCD_span。
      if (!option_ABCD_span) {
        continue
      }
      option_ABCD_span_list.push(option_ABCD_span)
      // 将选项span添加到数组中
      div.appendChild(option_ABCD_span)
      var width = option_ABCD_span.offsetWidth
      // 获取选项的宽度
      if (width > max_width) {
        max_width = width
      // 选择最长的长度
      }
    }

    var father_width = div.offsetWidth - 20

    /*
   * 根据最大选项长度，自动调整选项排布方式。
   */

    if (max_width > father_width / 2 || (max_width > father_width / 3 && option_ABCD_span_list.length == 3)) {
      for (var j = 0; j < option_ABCD_span_list.length; j++) {
        option_ABCD_span_list[j].style.width = father_width + 'px'
      }
    } else if (option_ABCD_span_list.length == 3) {
      for (var j = 0; j < option_ABCD_span_list.length; j++) {
        option_ABCD_span_list[j].style.width = father_width / 3 + 'px'
      }
    } else if (max_width > father_width / 4) {
      for (var j = 0; j < option_ABCD_span_list.length; j++) {
        option_ABCD_span_list[j].style.width = father_width / 2 + 'px'
      }
    } else {
      for (var j = 0; j < option_ABCD_span_list.length; j++) {
        option_ABCD_span_list[j].style.width = father_width / 4 + 'px'
      }
    }
  }
  if ((!sub_problem.answer) && (!sub_problem.analyze)) {
    return null
  }

  /*
 * ***********************
 * 下面是关于答案解析显示的部分
 * ***********************
 */

  var answer_analyze_div = document.createElement('DIV')
  answer_analyze_div.classList.add('answer_analyze_div')

  element.appendChild(answer_analyze_div)

  if (sub_problem.answer) {
    var div = document.createElement('DIV')
    answer_analyze_div.appendChild(div)
    div.className = 'answer_div'
    div.innerHTML = "<span class='answer_sign'>答案：</span>"
    entering.render_part(div, sub_problem.answer)
  }

  if (sub_problem.analyze) {
    var div = document.createElement('DIV')
    answer_analyze_div.appendChild(div)
    div.className = 'analyze_div'
    div.innerHTML = "<span class='analyze_sign'>解析：</span>"
    entering.render_part(div, sub_problem.analyze)
  }
}

entering.create_option_span = function (sub_porblem, s) {
  if (!sub_porblem['option_' + s]) {
    return null
  }
  var span = document.createElement('SPAN')
  span.className = 'option_ABCD_span'
  span.innerHTML = '<span>' + s + '．</span>'
  entering.render_part(span, sub_porblem['option_' + s])
  return span
}

entering.render_part = function (element, part) {
/*
 * 将part渲染在element中
 * part渲染成div，而sub_part渲染成span
 *
 */

  for (var i = 0; i < part.length; i++) {
    var sub_part_span = document.createElement('SPAN')
    element.appendChild(sub_part_span)
    sub_part_span.classList.add('sub_part_' + part[i].type)// sub_part的类名为sub_part_[类型]，例如sub_part_math_form(数学公式)，sub_part_normal(普通文本)。等等。

    if (part[i].type == 'math_form' || part[i].type == 'blank') {
      sub_part_span.innerHTML = part[i].source
      renderMathInElement(
        sub_part_span,
        {
          delimiters: [
            {left: '$$', right: '$$', display: true},
            {left: '\\[', right: '\\]', display: false},
            {left: '$', right: '$', display: false},
            {left: '\\(', right: '\\)', display: false}
          ]
        }
      )
    } else if (part[i].type == 'article') {
      sub_part_span.innerHTML = part[i].source.slice(1, -1)// 引用文章两边的标记去掉
    } else if (part[i].type == 'image') {
      var img = document.createElement('IMG')
      sub_part_span.appendChild(img)
      img.src = part[i].source.slice(1, -1)
      // 引用图片，两边的标记去掉，剩下的就是链接地址
      img.alt = part[i].source.slice(1, -1) + '加载失败'
    } else if (part[i].type == 'new_line') {
      if (i == 0 || part[i - 1].type != 'article') {
        sub_part_span.innerHTML = '</br>'
      };
    } else {
      sub_part_span.innerHTML = part[i].source
    }
  }
}

/*
* ************************************
* 下面是关于代码写入区域
* **************************************
*/

entering.write_problem = function (element, problem) {
  console.log('write - problem ', problem)
  element.innerHTML = ''
  for (var i = 0; i < problem.length; i++) {
    var sub_problem = problem[i]
    var part_name_list = ['stem', 'option_A', 'option_B', 'option_C', 'option_D', 'answer', 'analyze']

    for (var j = 0; j < part_name_list.length; j++) {
      entering.write_part(element, sub_problem, i, part_name_list[j])
    }
  }
}

entering.write_part = function (element, sub_problem, i, part_name) {
  var part = sub_problem[part_name]
  if (!part) {
    return null
  }
  var div = document.createElement('DIV')
  element.appendChild(div)

  var sign_part = {source: '', index: -1, type: 'sign'}
  if (part_name == 'stem' && i > 0) {
    sign_part.source = '(' + i + ')'
  } else if (part_name == 'answer') {
    sign_part.source = '答案：'
  } else if (part_name == 'analyze') {
    sign_part.source = '解析：'
  } else if (part_name.slice(0, -1) == 'option_') {
    sign_part.source = part_name[part_name.length - 1] + '．'
  }

  entering.write_sub_part(div, sign_part)
  for (var i = 0; i < part.length; i++) {
    entering.write_sub_part(div, part[i])
  }
}

entering.write_sub_part = function (element, sub_part) {
  var span = document.createElement('SPAN')

  span.className = sub_part.type

  if (sub_part.type == 'image') {
    var img = document.createElement('IMG')
    span.appendChild(img)
    img.src = sub_part.source.slice(1, -1)
    img.alt = sub_part.source.slice(1, -1) + '加载失败'
  } else if (sub_part.type == 'new_line') {
    span.innerHTML = '</br>'
  } else {
    span.innerHTML = sub_part.source
  }

  element.appendChild(span)
}

/*
* ************************************
* 生成统一模式
* **************************************
*/

entering.render_control_problem = function (element, problem) {
  var render_problem_div = document.createElement('DIV')
  render_problem_div.classList.add('大div')
  var left_control = document.createElement('DIV')
  var right_control = document.createElement('DIV')
  element.appendChild(render_problem_div)
  element.appendChild(left_control)
  element.appendChild(right_control)
  entering.render_problem(render_problem_div, problem)
  var answer_button = document.createElement('BUTTON')
  answer_button.innerHTML = '收起答案'
  left_control.appendChild(answer_button)
}

export default entering
